'use strict'

const { Controller } = require('egg')

// 用户名格式验证
const pattern = /^[\w-]{3,16}$/
class AdminUserController extends Controller {
  // 用户注册
  async register() {
    const { ctx, service } = this
    // 参数验证
    ctx.validate({
      username: {
        type: 'string',
        required: true,
        trim: true,
        desc: '用户名'
      },
      password: {
        type: 'string',
        required: true,
        trim: true,
        desc: '密码'
      },
      avatar: {
        type: 'string',
        desc: '头像'
      },
      type: {
        type: 'int',
        defValue: 1,
        desc: '类型-1:管理员,2:超级管理员'
      }
    })
    let { username, password, avatar, type } = ctx.request.body
    if (!pattern.test(username)) {
      return ctx.apiFail('用户名长度为3~16位(字母,数字,下划线,减号)', 422)
    }
    if (!pattern.test(password)) {
      return ctx.apiFail('密码长度为3~16位(字母,数字,下划线,减号)', 422)
    }
    // 随机生成头像
    avatar = avatar ? avatar : Math.floor(Math.random() * 14).toString()
    // 注册
    let user = await service.adminUser.register({ username, password, avatar, type })
    user = user.toJSON()
    Reflect.deleteProperty(user, 'password')

    ctx.apiSuccess(user)
  }
  // 用户登录
  async login() {
    const { ctx, app, service } = this
    // 参数验证
    ctx.validate({
      username: { type: 'string', required: true, range: { min: 3, max: 16 }, desc: '用户名' },
      password: { type: 'string', required: true, range: { min: 3, max: 16 }, desc: '密码' }
    })
    let { username, password } = ctx.request.body
    // 1.用户是否存在
    let user = await app.model.AdminUser.findOne({ where: { username } })
    if (!user) ctx.throw(400, '用户不存在')
    // 2.验证密码
    ctx.checkPassword(password, user.password)
    // 3.返回用户信息和token
    user = user.toJSON()
    // 权限 -- 判断用户是否是超级管理员
    if (user.type === 2) {
      user.permissions = ['*:*:*']
    } else {
      // 获取用户对应的角色id
      const role = await service.adminUser.getRole(user.id)
      const roleIds = role[0].roles.map((item) => item.id)
      // 获取角色对应的权限列表
      const perms = await service.adminUser.getPermissions(roleIds)
      let permsList = []
      perms.forEach((item) => {
        const p = item.permissions.map((v) => v.class)
        permsList.push(...p)
      })
      permsList = [...new Set(permsList)]
      user.permissions = permsList
    }
    Reflect.deleteProperty(user, 'password')
    user.token = ctx.signAccessToken({ id: user.id })

    ctx.apiSuccess(user)
  }
  // 获取管理员列表
  async getList() {
    const { ctx, app } = this
    // 参数验证
    ctx.validate({
      page: { type: 'int', desc: '页码' },
      pageSize: { type: 'int', desc: '每页条数' },
      username: { type: 'string', desc: '用户名' },
      type: { type: 'int', range: { in: [1, 2] }, desc: '类型-1:管理员,2:超级管理员' }
    })
    const { username, type } = ctx.request.query
    const Op = app.Sequelize.Op
    // 整理查询条件
    let where = {}
    if (username) where.username = { [Op.like]: `%${username}%` }
    if (type) where.type = type

    const result = await ctx.page('AdminUser', where, {
      include: [
        {
          model: app.model.Role,
          attributes: ['id', 'role_name'],
          through: {
            attributes: []
          }
        }
      ],
      attributes: {
        exclude: ['password']
      }
    })
    ctx.apiSuccess(result)
  }
  // 修改管理员信息
  async updateAdminUser() {
    const { ctx, app, service } = this
    // 参数验证
    ctx.validate({
      id: { type: 'int', required: true, desc: '管理员id' },
      avatar: { type: 'string', desc: '头像路径' },
      type: { type: 'int', desc: '类型-1:管理员,2:超级管理员' }
    })
    const { id, avatar, type } = ctx.request.body
    // 查询数据库
    const adminUser = await app.model.AdminUser.findOne({ where: { id } })
    if (!adminUser) ctx.throw(400, '该记录不存在')
    // 判断头像是否更新了
    if (avatar !== adminUser.avatar) {
      if (!avatar.startsWith('http')) return ctx.apiFail('头像需要是网络地址')
      // 删除旧头像
      await service.common.deleteFiles([adminUser.avatar])
    }
    const params = {}
    if (avatar) params.avatar = avatar
    if (type) params.type = type
    await adminUser.update(params)

    ctx.apiSuccess('修改成功')
  }
  // 删除管理员
  async deleteAdminUser() {
    const { ctx, app, service } = this
    // 参数验证
    ctx.validate({
      ids: { type: 'string', required: true, desc: '用户id' }
    })
    let { ids } = ctx.request.body
    // 整理参数
    ids = ids.split(',').map((id) => parseInt(id))
    // 删除oss上的图片
    const adminUserList = await app.model.AdminUser.findAll({ where: { id: ids } })
    const fileUrls = adminUserList
      .filter((item) => item.avatar?.startsWith('http'))
      .map((item) => item.avatar)
    await service.common.deleteFiles(fileUrls)
    const result = await app.model.AdminUser.destroy({ where: { id: ids } })
    // 删除管理员角色关联数据
    app.model.UserRole.destroy({ where: { uid: ids } })

    ctx.apiSuccess(result)
  }
}

module.exports = AdminUserController
